home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / language / asxsrc.arc / M01ADR.C < prev    next >
C/C++ Source or Header  |  1989-08-25  |  3KB  |  161 lines
  1. /* m01adr.c */
  2.  
  3. /*
  4.  * (C) Copyright 1989
  5.  * All Rights Reserved
  6.  *
  7.  * Alan R. Baldwin
  8.  * 721 Berkeley St.
  9.  * Kent, Ohio  44240
  10.  */
  11.  
  12. #include <stdio.h>
  13. #include <setjmp.h>
  14. #include "asm.h"
  15. #include "6801.h"
  16.  
  17. int
  18. addr(esp)
  19. register struct expr *esp;
  20. {
  21.     register c;
  22.     register struct area *espa;
  23.  
  24.     if ((c = getnb()) == '#') {
  25.         expr(esp, 0);
  26.         esp->e_mode = S_IMMED;
  27.     } else if (c == ',') {
  28.         esp->e_mode = S_INDX;
  29.         esp->e_flag = 0;
  30.         esp->e_addr = 0;
  31.         esp->e_base.e_ap = NULL;
  32.         if (admode(abdx) != S_X)
  33.             aerr();
  34.     } else if (c == '*') {
  35.         expr(esp, 0);
  36.         esp->e_mode = S_DIR;
  37.         espa = esp->e_base.e_ap;
  38.         if (esp->e_addr & ~0xFF)
  39.             aerr();
  40.         if (espa && espa != sdp->s_area)
  41.             rerr();
  42.         if (more()) {
  43.             comma();
  44.             esp->e_mode = S_INDX;
  45.             if (admode(abdx) != S_X)
  46.                 aerr();
  47.         }
  48.     } else {
  49.         unget(c);
  50.         if (esp->e_mode = admode(abdx)) {
  51.             ;
  52.         } else {
  53.             expr(esp, 0);
  54.             if (more()) {
  55.                 comma();
  56.                 esp->e_mode = S_INDX;
  57.                 if (admode(abdx) != S_X)
  58.                     aerr();
  59.                 espa = esp->e_base.e_ap;
  60.                 if (esp->e_addr & ~0xFF)
  61.                     aerr();
  62.                 if (espa && espa != sdp->s_area)
  63.                     rerr();
  64.             } else {
  65.                 if ( !esp->e_base.e_ap &&
  66.                     !(esp->e_addr & ~0xFF)) {
  67.                     esp->e_mode = S_DIR;
  68.                 } else {
  69.                     esp->e_mode = S_EXT;
  70.                 }
  71.             }
  72.         }
  73.     }
  74.     return (esp->e_mode);
  75. }
  76.     
  77. /*
  78.  * Enter admode() to search a specific addressing mode table
  79.  * for a match. Return the addressing value on a match or
  80.  * zero for no match.
  81.  */
  82. int
  83. admode(sp)
  84. register struct adsym *sp;
  85. {
  86.     register char *ptr;
  87.     register int i;
  88.     unget(getnb());
  89.     i = 0;
  90.     while ( *(ptr = (char *) &sp[i].a_str) ) {
  91.         if (srch(ptr)) {
  92.             return(sp[i].a_val);
  93.         }
  94.         i++;
  95.     }
  96.     return(0);
  97. }
  98.  
  99. /*
  100.  *      srch --- does string match ?
  101.  */
  102. int
  103. srch(str)
  104. register char *str;
  105. {
  106.     register char *ptr;
  107.     ptr = ip;
  108.  
  109. #if    CASE_SENSITIVE
  110.     while (*ptr && *str) {
  111.         if(*ptr != *str)
  112.             break;
  113.         ptr++;
  114.         str++;
  115.     }
  116.     if (*ptr == *str) {
  117.         ip = ptr;
  118.         return(1);
  119.     }
  120. #else
  121.     while (*ptr && *str) {
  122.         if(ccase[*ptr] != ccase[*str])
  123.             break;
  124.         ptr++;
  125.         str++;
  126.     }
  127.     if (ccase[*ptr] == ccase[*str]) {
  128.         ip = ptr;
  129.         return(1);
  130.     }
  131. #endif
  132.  
  133.     if (!*str)
  134.         if (any(*ptr," \t\n,];")) {
  135.             ip = ptr;
  136.             return(1);
  137.         }
  138.     return(0);
  139. }
  140.  
  141. /*
  142.  *      any --- does str contain c?
  143.  */
  144. int
  145. any(c,str)
  146. char    c, *str;
  147. {
  148.     while (*str)
  149.         if(*str++ == c)
  150.             return(1);
  151.     return(0);
  152. }
  153.  
  154. struct adsym    abdx[] = {    /* a, b, d, or x registers */
  155.     "a",    S_A,
  156.     "b",    S_B,
  157.     "d",    S_D,
  158.     "x",    S_X,
  159.     "",    0x00
  160. };
  161.